M

MLOG

తెలుగు

జావాస్క్రిప్ట్ ఇటరేటర్ ప్రోటోకాల్‌ను అర్థం చేసుకోవడానికి మరియు అమలు చేయడానికి ఒక సమగ్ర గైడ్. ఇది మెరుగైన డేటా హ్యాండ్లింగ్ కోసం కస్టమ్ ఇటరేటర్లను సృష్టించడానికి మిమ్మల్ని శక్తివంతం చేస్తుంది.

జావాస్క్రిప్ట్ ఇటరేటర్ ప్రోటోకాల్ మరియు కస్టమ్ ఇటరేటర్ల రహస్యాలను ఛేదించడం

జావాస్క్రిప్ట్ యొక్క ఇటరేటర్ ప్రోటోకాల్ డేటా స్ట్రక్చర్‌లను దాటడానికి (traverse) ఒక ప్రామాణిక మార్గాన్ని అందిస్తుంది. ఈ ప్రోటోకాల్‌ను అర్థం చేసుకోవడం డెవలపర్‌లకు శ్రేణులు (arrays) మరియు స్ట్రింగ్స్ వంటి అంతర్నిర్మిత ఇటరబుల్స్‌తో సమర్థవంతంగా పనిచేయడానికి, మరియు నిర్దిష్ట డేటా స్ట్రక్చర్‌లు మరియు అప్లికేషన్ అవసరాలకు అనుగుణంగా వారి స్వంత కస్టమ్ ఇటరబుల్స్‌ను సృష్టించడానికి శక్తినిస్తుంది. ఈ గైడ్ ఇటరేటర్ ప్రోటోకాల్ గురించి మరియు కస్టమ్ ఇటరేటర్లను ఎలా అమలు చేయాలో సమగ్రమైన అన్వేషణను అందిస్తుంది.

ఇటరేటర్ ప్రోటోకాల్ అంటే ఏమిటి?

ఇటరేటర్ ప్రోటోకాల్ ఒక ఆబ్జెక్ట్‌ను ఎలా ఇటరేట్ చేయాలో, అంటే దానిలోని ఎలిమెంట్స్‌ను వరుసగా ఎలా యాక్సెస్ చేయాలో నిర్వచిస్తుంది. ఇందులో రెండు భాగాలు ఉంటాయి: ఇటరబుల్ ప్రోటోకాల్ మరియు ఇటరేటర్ ప్రోటోకాల్.

ఇటరబుల్ ప్రోటోకాల్

ఒక ఆబ్జెక్ట్‌కు Symbol.iterator అనే కీతో ఒక మెథడ్ ఉంటే, అది ఇటరబుల్ (Iterable) అని పరిగణించబడుతుంది. ఈ మెథడ్ తప్పనిసరిగా ఇటరేటర్ ప్రోటోకాల్‌కు అనుగుణంగా ఉన్న ఒక ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వాలి.

సారూప్యంగా చెప్పాలంటే, ఒక ఇటరబుల్ ఆబ్జెక్ట్ తన కోసం ఒక ఇటరేటర్‌ను ఎలా సృష్టించాలో తెలుసుకుంటుంది.

ఇటరేటర్ ప్రోటోకాల్

ఇటరేటర్ ప్రోటోకాల్ ఒక సీక్వెన్స్ నుండి విలువలను ఎలా పొందాలో నిర్వచిస్తుంది. ఒక ఆబ్జెక్ట్‌కు next() మెథడ్ ఉంటే, అది ఒక ఇటరేటర్‌గా పరిగణించబడుతుంది. ఈ మెథడ్ రెండు ప్రాపర్టీలతో ఒక ఆబ్జెక్ట్‌ను తిరిగి ఇస్తుంది:

next() మెథడ్ ఇటరేటర్ ప్రోటోకాల్ యొక్క ముఖ్యమైన భాగం. ప్రతిసారి next()ను పిలిచినప్పుడు, ఇటరేటర్ ముందుకు సాగి, సీక్వెన్స్‌లోని తదుపరి విలువను తిరిగి ఇస్తుంది. అన్ని విలువలు తిరిగి ఇచ్చిన తర్వాత, next() ఒక doneను trueగా సెట్ చేసిన ఆబ్జెక్ట్‌ను తిరిగి ఇస్తుంది.

అంతర్నిర్మిత ఇటరబుల్స్

జావాస్క్రిప్ట్ స్వాభావికంగా ఇటరబుల్ అయిన అనేక అంతర్నిర్మిత డేటా స్ట్రక్చర్‌లను అందిస్తుంది. వీటిలో ఇవి ఉన్నాయి:

ఈ ఇటరబుల్స్‌ను for...of లూప్, స్ప్రెడ్ సింటాక్స్ (...), మరియు ఇటరేటర్ ప్రోటోకాల్‌పై ఆధారపడే ఇతర నిర్మాణాలతో నేరుగా ఉపయోగించవచ్చు.

శ్రేణులతో ఉదాహరణ:


const myArray = ["apple", "banana", "cherry"];

for (const item of myArray) {
  console.log(item); // Output: apple, banana, cherry
}

స్ట్రింగ్స్‌తో ఉదాహరణ:


const myString = "Hello";

for (const char of myString) {
  console.log(char); // Output: H, e, l, l, o
}

for...of లూప్

for...of లూప్ ఇటరబుల్ ఆబ్జెక్ట్‌లపై ఇటరేట్ చేయడానికి ఒక శక్తివంతమైన నిర్మాణం. ఇది ఇటరేటర్ ప్రోటోకాల్ యొక్క సంక్లిష్టతలను స్వయంచాలకంగా నిర్వహిస్తుంది, సీక్వెన్స్‌లోని విలువలను యాక్సెస్ చేయడం సులభం చేస్తుంది.

for...of లూప్ యొక్క సింటాక్స్:


for (const element of iterable) {
  // ప్రతి ఎలిమెంట్ కోసం అమలు చేయవలసిన కోడ్
}

for...of లూప్ ఇటరబుల్ ఆబ్జెక్ట్ నుండి ఇటరేటర్‌ను పొందుతుంది (Symbol.iterator ఉపయోగించి), మరియు ఇటరేటర్ యొక్క next() మెథడ్‌ను done true అయ్యే వరకు పదేపదే పిలుస్తుంది. ప్రతి ఇటరేషన్‌లో, element వేరియబుల్‌కు next() ద్వారా తిరిగి ఇవ్వబడిన value ప్రాపర్టీ కేటాయించబడుతుంది.

కస్టమ్ ఇటరేటర్లను సృష్టించడం

జావాస్క్రిప్ట్ అంతర్నిర్మిత ఇటరబుల్స్‌ను అందిస్తున్నప్పటికీ, ఇటరేటర్ ప్రోటోకాల్ యొక్క నిజమైన శక్తి మీ స్వంత డేటా స్ట్రక్చర్‌ల కోసం కస్టమ్ ఇటరేటర్లను నిర్వచించగల సామర్థ్యంలో ఉంది. ఇది మీ డేటాను ఎలా దాటాలి మరియు యాక్సెస్ చేయాలో నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఒక కస్టమ్ ఇటరేటర్‌ను ఎలా సృష్టించాలో ఇక్కడ ఉంది:

  1. మీ కస్టమ్ డేటా స్ట్రక్చర్‌ను సూచించే ఒక క్లాస్ లేదా ఆబ్జెక్ట్‌ను నిర్వచించండి.
  2. మీ క్లాస్ లేదా ఆబ్జెక్ట్‌పై Symbol.iterator మెథడ్‌ను అమలు చేయండి. ఈ మెథడ్ ఒక ఇటరేటర్ ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వాలి.
  3. ఇటరేటర్ ఆబ్జెక్ట్‌లో తప్పనిసరిగా next() మెథడ్ ఉండాలి, అది value మరియు done ప్రాపర్టీలతో ఒక ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వాలి.

ఉదాహరణ: ఒక సింపుల్ రేంజ్ కోసం ఇటరేటర్‌ను సృష్టించడం

సంఖ్యల శ్రేణిని సూచించే Range అనే క్లాస్‌ను సృష్టిద్దాం. శ్రేణిలోని సంఖ్యలపై ఇటరేట్ చేయడానికి ఇటరేటర్ ప్రోటోకాల్‌ను అమలు చేద్దాం.


class Range {
  constructor(start, end) {
    this.start = start;
    this.end = end;
  }

  [Symbol.iterator]() {
    let currentValue = this.start;
    const that = this; // Capture 'this' for use inside the iterator object

    return {
      next() {
        if (currentValue <= that.end) {
          return {
            value: currentValue++,
            done: false,
          };
        } else {
          return {
            value: undefined,
            done: true,
          };
        }
      },
    };
  }
}

const myRange = new Range(1, 5);

for (const number of myRange) {
  console.log(number); // Output: 1, 2, 3, 4, 5
}

వివరణ:

ఉదాహరణ: ఒక లింక్డ్ లిస్ట్ కోసం ఇటరేటర్‌ను సృష్టించడం

మరొక ఉదాహరణను పరిశీలిద్దాం: లింక్డ్ లిస్ట్ డేటా స్ట్రక్చర్ కోసం ఒక ఇటరేటర్‌ను సృష్టించడం. లింక్డ్ లిస్ట్ అనేది నోడ్ల వరుస, ఇక్కడ ప్రతి నోడ్ ఒక విలువను మరియు జాబితాలోని తదుపరి నోడ్‌కు ఒక సూచనను (పాయింటర్) కలిగి ఉంటుంది. జాబితాలోని చివరి నోడ్ null (లేదా undefined)కు సూచనను కలిగి ఉంటుంది.


class LinkedListNode {
    constructor(value, next = null) {
        this.value = value;
        this.next = next;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    append(value) {
        const newNode = new LinkedListNode(value);
        if (!this.head) {
            this.head = newNode;
            return;
        }

        let current = this.head;
        while (current.next) {
            current = current.next;
        }
        current.next = newNode;
    }

    [Symbol.iterator]() {
        let current = this.head;

        return {
            next() {
                if (current) {
                    const value = current.value;
                    current = current.next;
                    return {
                        value: value,
                        done: false
                    };
                } else {
                    return {
                        value: undefined,
                        done: true
                    };
                }
            }
        };
    }
}

// Example Usage:
const myList = new LinkedList();
myList.append("London");
myList.append("Paris");
myList.append("Tokyo");

for (const city of myList) {
    console.log(city); // Output: London, Paris, Tokyo
}

వివరణ:

జెనరేటర్ ఫంక్షన్లు

జెనరేటర్ ఫంక్షన్లు ఇటరేటర్లను సృష్టించడానికి మరింత సంక్షిప్తమైన మరియు సొగసైన మార్గాన్ని అందిస్తాయి. అవి డిమాండ్‌పై విలువలను ఉత్పత్తి చేయడానికి yield కీవర్డ్‌ను ఉపయోగిస్తాయి.

ఒక జెనరేటర్ ఫంక్షన్ function* సింటాక్స్ ఉపయోగించి నిర్వచించబడుతుంది.

ఉదాహరణ: జెనరేటర్ ఫంక్షన్‌ను ఉపయోగించి ఇటరేటర్‌ను సృష్టించడం

Range ఇటరేటర్‌ను జెనరేటర్ ఫంక్షన్‌ను ఉపయోగించి తిరిగి వ్రాద్దాం:


class Range {
  constructor(start, end) {
    this.start = start;
    this.end = end;
  }

  *[Symbol.iterator]() {
    for (let i = this.start; i <= this.end; i++) {
      yield i;
    }
  }
}

const myRange = new Range(1, 5);

for (const number of myRange) {
  console.log(number); // Output: 1, 2, 3, 4, 5
}

వివరణ:

జెనరేటర్ ఫంక్షన్లు next() మెథడ్ మరియు done ఫ్లాగ్‌ను స్వయంచాలకంగా నిర్వహించడం ద్వారా ఇటరేటర్ సృష్టిని సులభతరం చేస్తాయి.

ఉదాహరణ: ఫిబొనాక్సీ సీక్వెన్స్ జెనరేటర్

జెనరేటర్ ఫంక్షన్లను ఉపయోగించడానికి మరొక గొప్ప ఉదాహరణ ఫిబొనాక్సీ సీక్వెన్స్‌ను రూపొందించడం:


function* fibonacciSequence() {
  let a = 0;
  let b = 1;

  while (true) {
    yield a;
    [a, b] = [b, a + b]; // Destructuring assignment for simultaneous update
  }
}

const fibonacci = fibonacciSequence();

for (let i = 0; i < 10; i++) {
  console.log(fibonacci.next().value); // Output: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
}

వివరణ:

ఇటరేటర్ ప్రోటోకాల్ ఉపయోగించడం వల్ల ప్రయోజనాలు

అధునాతన ఇటరేటర్ టెక్నిక్స్

ఇటరేటర్లను కలపడం

మీరు బహుళ ఇటరేటర్లను ఒకే ఇటరేటర్‌గా కలపవచ్చు. మీరు బహుళ మూలాల నుండి డేటాను ఏకీకృత మార్గంలో ప్రాసెస్ చేయవలసి వచ్చినప్పుడు ఇది ఉపయోగపడుతుంది.


function* combineIterators(...iterables) {
  for (const iterable of iterables) {
    for (const item of iterable) {
      yield item;
    }
  }
}

const array1 = [1, 2, 3];
const array2 = ["a", "b", "c"];
const string1 = "XYZ";

const combined = combineIterators(array1, array2, string1);

for (const value of combined) {
  console.log(value); // Output: 1, 2, 3, a, b, c, X, Y, Z
}

ఈ ఉదాహరణలో, `combineIterators` ఫంక్షన్ ఎన్ని ఇటరబుల్స్‌నైనా ఆర్గ్యుమెంట్‌లుగా తీసుకుంటుంది. ఇది ప్రతి ఇటరబుల్‌పై ఇటరేట్ చేసి, ప్రతి ఐటమ్‌ను యీల్డ్ చేస్తుంది. ఫలితంగా అన్ని ఇన్‌పుట్ ఇటరబుల్స్ నుండి అన్ని విలువలను ఉత్పత్తి చేసే ఒకే ఇటరేటర్ వస్తుంది.

ఇటరేటర్లను ఫిల్టర్ చేయడం మరియు మార్చడం

మీరు మరొక ఇటరేటర్ ద్వారా ఉత్పత్తి చేయబడిన విలువలను ఫిల్టర్ చేసే లేదా మార్చే ఇటరేటర్లను కూడా సృష్టించవచ్చు. ఇది డేటాను ఒక పైప్‌లైన్‌లో ప్రాసెస్ చేయడానికి, ప్రతి విలువ ఉత్పత్తి అయినప్పుడు దానికి వివిధ ఆపరేషన్లను వర్తింపజేయడానికి మిమ్మల్ని అనుమతిస్తుంది.


function* filterIterator(iterable, predicate) {
  for (const item of iterable) {
    if (predicate(item)) {
      yield item;
    }
  }
}

function* mapIterator(iterable, transform) {
  for (const item of iterable) {
    yield transform(item);
    }
}

const numbers = [1, 2, 3, 4, 5, 6];

const evenNumbers = filterIterator(numbers, (x) => x % 2 === 0);
const squaredEvenNumbers = mapIterator(evenNumbers, (x) => x * x);

for (const value of squaredEvenNumbers) {
    console.log(value); // Output: 4, 16, 36
}

ఇక్కడ, `filterIterator` ఒక ఇటరబుల్ మరియు ఒక ప్రిడికేట్ ఫంక్షన్‌ను తీసుకుంటుంది. ప్రిడికేట్ `true` తిరిగి ఇచ్చే ఐటమ్స్‌ను మాత్రమే ఇది యీల్డ్ చేస్తుంది. `mapIterator` ఒక ఇటరబుల్ మరియు ఒక ట్రాన్స్‌ఫార్మ్ ఫంక్షన్‌ను తీసుకుంటుంది. ఇది ప్రతి ఐటమ్‌కు ట్రాన్స్‌ఫార్మ్ ఫంక్షన్‌ను వర్తింపజేయడం ద్వారా వచ్చే ఫలితాన్ని యీల్డ్ చేస్తుంది.

నిజ-ప్రపంచ అప్లికేషన్లు

ఇటరేటర్ ప్రోటోకాల్ జావాస్క్రిప్ట్ లైబ్రరీలు మరియు ఫ్రేమ్‌వర్క్‌లలో విస్తృతంగా ఉపయోగించబడుతుంది, మరియు ఇది వివిధ నిజ-ప్రపంచ అప్లికేషన్లలో, ముఖ్యంగా పెద్ద డేటాసెట్‌లు లేదా అసమకాలిక కార్యకలాపాలతో వ్యవహరించేటప్పుడు విలువైనది.

ఉత్తమ పద్ధతులు

ముగింపు

జావాస్క్రిప్ట్ ఇటరేటర్ ప్రోటోకాల్ డేటా స్ట్రక్చర్‌లను దాటడానికి శక్తివంతమైన మరియు సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది. ఇటరబుల్ మరియు ఇటరేటర్ ప్రోటోకాల్స్‌ను అర్థం చేసుకోవడం ద్వారా, మరియు జెనరేటర్ ఫంక్షన్లను ఉపయోగించడం ద్వారా, మీరు మీ నిర్దిష్ట అవసరాలకు అనుగుణంగా కస్టమ్ ఇటరేటర్లను సృష్టించవచ్చు. ఇది డేటాతో సమర్థవంతంగా పనిచేయడానికి, కోడ్ చదవడానికి సులభంగా ఉండటానికి, మరియు మీ అప్లికేషన్ల పనితీరును మెరుగుపరచడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇటరేటర్లపై పట్టు సాధించడం జావాస్క్రిప్ట్ యొక్క సామర్థ్యాల గురించి లోతైన అవగాహనను అన్‌లాక్ చేస్తుంది మరియు మరింత సొగసైన మరియు సమర్థవంతమైన కోడ్‌ను వ్రాయడానికి మిమ్మల్ని శక్తివంతం చేస్తుంది.